ก้าวแรกสู่ Quantum Computing

ความยาก: Beginner
เวลาใช้งาน QPU: 11 วินาที

ยินดีต้อนรับ แฮกเกอร์ทุกคน! เรายินดีมากที่มีคุณอยู่ในเวิร์กช็อปนี้ เป้าหมายหลักของการลองปฏิบัติเบื้องต้นนี้คือเตรียมความพร้อมให้คุณออกเดินทางในโลกควอนตัม ด้วย 1) แนะนำวิธีติดตั้ง Qiskit 2) สร้างบัญชี IBM Cloud และเตรียม api_key กับ crn เพื่อใช้คอมพิวเตอร์ควอนตัมจริง 3) สร้าง Circuit ควอนตัมแรกของคุณ 4) แก้ควิซสถานะควอนตัม และ 5) รัน Circuit บนคอมพิวเตอร์ควอนตัมจริงและพล็อตผลลัพธ์

1. เริ่มต้นด้วยสิ่งแรก: Qiskit

Qiskit คืออะไร

Qiskit SDK คือชุดซอฟต์แวร์ประสิทธิภาพสูงที่สร้างขึ้นเพื่อช่วยให้นักพัฒนาและนักวิจัยดึงศักยภาพสูงสุดจากคอมพิวเตอร์ควอนตัมในระดับยูทิลิตีและก้าวล้ำไปกว่านั้น หัวใจหลักคือ Qiskit SDK ซึ่งเป็น open source software development kit สำหรับทำงานกับคอมพิวเตอร์ควอนตัมในระดับ quantum circuit แบบขยาย Operator และ Primitive Qiskit SDK เปิดโอกาสให้ทุกคนได้รับประสิทธิภาพสูงสุดจากคอมพิวเตอร์ควอนตัมจริงด้วยสภาพแวดล้อมการคำนวณที่ตัวเองถนัด

นอกจาก SDK แล้ว Qiskit ยังมีชุดเครื่องมือและบริการประสิทธิภาพสูง เช่น Qiskit Runtime Service ที่เปิดให้ทำการคำนวณแบบ optimized บนคอมพิวเตอร์ควอนตัม IBM ผ่านคลาวด์ด้วย Primitive ที่จัดการ error mitigation และ Qiskit Transpiler Service ที่ให้วิธีการแบบ heuristic และ AI สำหรับ optimize quantum circuit อย่างทันสมัย

Qiskit functions คือแค็ตตาล็อกบริการของ IBM และบุคคลที่สามที่ช่วยให้ optimize workload และนำ Qiskit ไปใช้กับอุตสาหกรรมได้ง่ายขึ้น ไม่ว่าคุณจะเป็นนักพัฒนาซอฟต์แวร์ควอนตัม นักทดลองควอนตัม นักวิทยาศาสตร์การคำนวณ หรือแค่ต้องการเริ่มต้น framework แบบ modular และยืดหยุ่นของ Qiskit ก็ช่วยให้คุณทำงานในระดับ abstraction ที่เหมาะกับความต้องการได้

Qiskit ออกแบบมาเพื่อรองรับการขยายและปรับแต่ง ทำให้สกัดประสิทธิภาพชั้นนำในอุตสาหกรรมและรับมือกับปัญหาใหม่ๆ ได้ code base ประสิทธิภาพสูงทำให้ Qiskit SDK ทำงานเร็วขึ้น ใช้หน่วยความจำน้อยลง และให้ผลลัพธ์ที่ดีกว่าเดิม นอกจากนี้ Qiskit ยังเชื่อมคุณกับชุมชนผู้ใช้และนักพัฒนาจำนวนมากที่พร้อมต้อนรับและตอบคำถาม โครงการ Qiskit advocate เปิดตัวครั้งแรกในปี 2019 เป็นความริเริ่มระดับโลกที่มุ่งเน้นชุมชน ดึงดูดผู้เชี่ยวชาญและผู้ที่หลงใหลในการคำนวณควอนตัมจากทั่วโลก ตลอดหลายปีที่ผ่านมา advocate หลายคนกลายเป็นผู้นำที่ได้รับการยอมรับในชุมชนควอนตัม อยากเป็นผู้นำควอนตัมรุ่นถัดไปไหม? อย่าลังเลที่จะสมัคร — ที่นี่

ติดตั้ง Qiskit

ก่อนอื่น ตรวจสอบว่า Python ที่ใช้ในสภาพแวดล้อมของคุณเป็นเวอร์ชัน python>=3.10 เพื่อให้แน่ใจว่าเข้ากันได้กับ Qiskit เวอร์ชันล่าสุดที่เราจะใช้

from platform import python_version

print(python_version())

หากไม่ใช่ ให้อัปเกรดด้วยเครื่องมือที่ถนัด หากไม่แน่ใจว่าจะทำอย่างไร มีตัวเลือกที่แนะนำดังนี้:

MacOS: Homebrew
Linux: sudo apt-get update

คู่มือการอัปเกรด Python ตาม OS แบบละเอียดอยู่ที่นี่: How to update Python

ดูข้อมูลเพิ่มเติมได้ที่ wiki ของ QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

ตรวจสอบการติดตั้งได้โดยรัน cell ด้านล่าง หากติดตั้งถูกต้อง จะแสดงเวอร์ชันของ Qiskit

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

การแก้ปัญหาเมื่อติดตั้งไม่สำเร็จ

หาก cell ก่อนหน้าเกิด error ให้ลองติดตั้ง Qiskit ใน virtual environment (มีสองวิธีที่แนะนำด้านล่าง) หากไม่มี error ให้ข้าม cell นี้และไปต่อ

เราเสนอสองวิธีในการตั้ง virtual environment เพื่อติดตั้ง Qiskit:

ใช้ venv ตามที่อธิบายในคู่มือ Qiskit installation guide
ใช้ conda ตามที่อธิบายในวิดีโอของ Coding with Qiskit

2. ตั้งค่าบัญชี IBM Cloud ของคุณ

ในการใช้คอมพิวเตอร์ควอนตัมจริง คุณต้องมี api key — ตั๋วหลักในการเข้าถึงคลาวด์ และ crn — token ที่จะดึง resource มาให้คุณเมื่อตั้งค่าบัญชีแล้ว

ตั้งค่าบัญชีตามขั้นตอนต่อไปนี้:

ไปที่ IBM Quantum® Platform
ไปที่มุมขวาบน (ดังภาพข้างต้น) สร้าง API token แล้วคัดลอกเก็บไว้ในที่ปลอดภัย
ใน cell ถัดไป ให้แทนที่ deleteThisAndPasteYourAPIKeyHere ด้วย API key ของคุณ
ไปที่มุมซ้ายล่าง (ดังภาพข้างต้น) แล้วสร้าง instance ของคุณ ให้แน่ใจว่าเลือก open plan
หลังจากสร้าง instance แล้ว คัดลอก CRN code ที่เชื่อมกับ instance นั้น อาจต้องรีเฟรชเพื่อดู instance
ใน cell ด้านล่าง ให้แทนที่ deleteThisAndPasteYourCRNHere ด้วย CRN code ของคุณ

ดูรายละเอียดเพิ่มเติมได้ที่ this guide สำหรับการตั้งค่าบัญชี IBM Cloud®

⚠️ หมายเหตุ: ดูแล API key ของคุณเหมือนรหัสผ่านที่ปลอดภัย ดู Cloud setup guide สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ API key ทั้งในสภาพแวดล้อมที่ปลอดภัยและไม่น่าเชื่อถือ

นอกจากนี้ หากคุณเป็นสมาชิกเครือข่ายพันธมิตรมหาวิทยาลัย IBM กรุณาใช้ที่อยู่อีเมลของสถาบันเป็น IBM ID เพื่อรับสิทธิ์ประโยชน์พันธมิตร

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Circuit ควอนตัมแรกของคุณ

Quantum circuit คืออะไร

หน่วยพื้นฐานของ Qiskit คือ quantum circuit ซึ่งเป็นชุดคำสั่งที่คอมพิวเตอร์ควอนตัมใช้ทำงานกับหน่วยข้อมูลควอนตัม หรือที่รู้จักกันในชื่อ Qubit Qubit เหล่านี้มีคุณสมบัติพิเศษที่ช่วยให้คอมพิวเตอร์ควอนตัมเข้าถึงปัญหาได้ต่างจากแล็ปท็อปหรือ iPhone ของคุณ Qiskit กำลังพัฒนาอย่างรวดเร็ว — แม้ว่าคุณยังสามารถออกแบบ Circuit ควอนตัมด้วยตัวเองและกำหนดวิธีรันได้ (และก็มีเหตุผลดีๆ มากมายที่จะทำเช่นนั้น) แต่ IBM Quantum ก็มีเครื่องมือที่ช่วยให้กระบวนการง่ายขึ้น เพื่อการเรียนรู้ เราจะออกแบบ Circuit ง่ายๆ แล้วรันบน simulator

เราข้ามภาพรวมนี้ไปอย่างรวดเร็ว เพราะจริงๆ แล้วเราอาจใช้เวลาหลายชั่วโมงแค่อธิบายพื้นฐานของข้อมูลและการคำนวณควอนตัม IBM Quantum ได้ทำสิ่งนี้ไว้แล้วโดยสร้าง written course และชุด video lectures ที่อุทิศให้กับเรื่องนี้ หากต้องการทบทวน ไปดูได้เลย!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

การทำงานพื้นฐานกับ Qubit และการวัด

การแทนสถานะ Qubit เดี่ยว

เริ่มจากมองที่ Qubit เดี่ยว ความแตกต่างหลักระหว่าง classical bit ซึ่งรับได้แค่ค่า 0 และ 1 กับ quantum bit หรือ Qubit คือ Qubit สามารถอยู่ในสถานะ $\vert0\rangle$ , $\vert1\rangle$ รวมถึง combination เชิงเส้นของสองสถานะนี้ได้ คุณสมบัตินี้เรียกว่า superposition และทำให้เราสามารถเขียนสถานะทั่วไปของ Qubit ได้ว่า:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

ถ้าวัดสถานะของ Qubit นี้ เราจะพบผลลัพธ์ $1$ ด้วยความน่าจะเป็น $p$ และผลลัพธ์ $0$ ด้วยความน่าจะเป็น $1-p$ อย่างที่เห็น ความน่าจะเป็นรวมกันได้ $1$ แสดงว่าเราจะวัดได้ $0$ หรือ $1$ เท่านั้น ไม่มีผลลัพธ์อื่น

นอกจาก $p$ แล้ว อาจสังเกตเห็น parameter อีกตัวข้างต้น ตัวแปร $\phi$ แทน relative quantum phase ระหว่างสองสถานะ $\vert0\rangle$ และ $\vert1\rangle$ อย่างที่เราจะพบในภายหลัง relative phase นี้สำคัญมาก สำหรับตอนนี้ ขอให้รู้ไว้ว่า quantum phase คือสิ่งที่ทำให้เกิด interference ระหว่างสถานะควอนตัม ส่งผลให้เราสามารถเขียน quantum algorithm สำหรับแก้ปัญหาเฉพาะได้

การแสดงภาพสถานะควอนตัม

เราแสดงสถานะควอนตัมในแบบฝึกหัดนี้ด้วยสิ่งที่เรียกว่า qsphere นี่คือลักษณะของ qsphere สำหรับสถานะ $\vert0\rangle$ และ $\vert1\rangle$ ตามลำดับ สังเกตว่าส่วนบนสุดของทรงกลมแทนสถานะ $\vert0\rangle$ ในขณะที่ส่วนล่างแทน $\vert1\rangle$

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

คุณสร้าง QSphere เดียวกันได้โดยใช้ quantum circuit สถานะ statevector ที่ใช้ที่นี่มาจากสถานะ $|0\rangle$ ใน Qiskit Qubit จะถูก initialize ในสถานะ $|0\rangle$ ลองรัน circuit ด้านล่างแล้วดูว่าได้ QSphere เหมือนกันไหม

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

ตอนนี้ลองแสดงภาพสถานะ $|1\rangle$ กัน ไม่น่าแปลกใจที่สถานะ superposition ที่มี quantum phase $\phi = 0$ และความน่าจะเป็น $p = 1/2$ (หมายถึงโอกาสเท่ากันที่จะวัดได้ทั้ง 0 และ 1) จะแสดงใน qsphere ด้วยสองจุด แต่สังเกตด้วยว่าขนาดของวงกลมที่จุดทั้งสองเล็กกว่าตอนที่มีแค่ $\vert0\rangle$ และ $\vert1\rangle$ เพราะขนาดวงกลมสัดส่วนกับความน่าจะเป็นที่จะวัดแต่ละค่า ซึ่งลดลงครึ่งหนึ่ง

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

ในกรณีของสถานะ superposition ที่ quantum phase ไม่เป็นศูนย์ qsphere ช่วยให้เราเห็น phase นั้นได้โดยเปลี่ยนสีของ blob ที่สอดคล้องกัน ตัวอย่างเช่น สถานะที่มี $\phi = 90^\circ$ (องศา) และความน่าจะเป็น $p = 1/2$ แสดงใน qsphere ด้านล่าง

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

การจัดการ Qubit

Qubit ถูกจัดการโดยการใช้ quantum Gate มาดูภาพรวมของ Gate ต่างๆ ที่เราจะใช้ในแบบฝึกหัดต่อไปนี้กัน

ก่อนอื่น มาอธิบายวิธีเปลี่ยนค่า $p$ สำหรับสถานะควอนตัมทั่วไปกัน เราจะใช้ Gate สองตัว:

$X$ -gate: Gate นี้สลับระหว่างสองสถานะ $\vert0\rangle$ และ $\vert1\rangle$ การทำงานนี้เหมือนกับ classical NOT gate ดังนั้น $X$ -gate บางครั้งเรียกว่า bit flip หรือ NOT gate ในทางคณิตศาสตร์ $X$ gate เปลี่ยน $p$ เป็น $1-p$ กล่าวคือจาก 0 เป็น 1 และในทางกลับกัน
$H$ -gate: Gate นี้ให้เราเดินทางจากสถานะ $\vert0\rangle$ ไปสู่สถานะ $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ สถานะนี้รู้จักกันในชื่อ $\vert+\rangle$ ในทางคณิตศาสตร์ หมายถึงการเดินทางจาก $p=0, \phi=0$ ไปสู่ $p=1/2, \phi=0$ เนื่องจากสถานะสุดท้ายของ Qubit เป็น superposition ของ $\vert0\rangle$ และ $\vert1\rangle$ Hadamard gate จึงเป็นการทำงานควอนตัมแท้จริง

สังเกตว่า Gate ทั้งสองเปลี่ยนค่า $p$ แต่ไม่เปลี่ยน $\phi$ โชคดีที่เราสามารถแสดงการทำงานของ Gate เหล่านี้ได้ง่ายๆ จากภาพด้านล่าง

คุณสามารถทดลองใช้ Gate $X$ , $Y$ , $Z$ , $H$ , $S$ และ $S^\dagger$ เพื่อทำความคุ้นเคยกับการดำเนินการต่างๆ และผลกระทบต่อสถานะของ qubit หากต้องการทำเช่นนั้น คุณสามารถเข้าไปที่ Circuit Composer แล้วเริ่มใช้ circuit widget ของเรา หลังจากเข้าไปที่ circuit composer แล้ว ให้เลือก Gate ที่จะ apply กับ qubit แล้วเลือก qubit (ในตัวอย่างแรก ๆ qubit ที่เลือกได้คือ qubit 0 เท่านั้น) ดูว่าสถานะที่สอดคล้องเปลี่ยนแปลงอย่างไรกับแต่ละ Gate รวมถึงคำอธิบายของสถานะนั้น และมันจะให้โค้ดที่สร้าง quantum circuit ที่สอดคล้องใน Qiskit ด้วย

ถ้าต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการอธิบายสถานะควอนตัม Pauli operators และ Gate สำหรับ Qubit เดี่ยวอื่นๆ ดูได้ที่ Quantum Information ของ Single System ในคอร์ส Basics of Quantum Information โดย John Watrous

แบบฝึกหัด: Quantum Circuit ด้วย Single-Qubit Gate

นี่คือแบบฝึกหัดเล็กๆ สี่ข้อสำหรับไปถึงสถานะต่างๆ บน qsphere คุณสามารถแก้โดยใช้ circuit composer แล้ว copy paste โค้ดที่ได้ไปใส่ใน cell ที่เกี่ยวข้องเพื่อสร้าง quantum circuit หรือจะเขียนโค้ดใส่ combination ของบรรทัดต่อไปนี้โดยตรงเพื่อ apply Gate ต่างๆ:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

(0) หมายความว่าเรา apply Gate นี้กับ Qubit q0 ซึ่งเป็น Qubit ตัวแรก (และในกรณีนี้ตัวเดียว)

ลองไปถึงสถานะที่กำหนดบน qsphere ในแต่ละแบบฝึกหัดต่อไปนี้

i) เริ่มจาก bit flip สิ่งที่ต้องทำคือไปถึงสถานะ $\vert1\rangle$ โดยเริ่มจากสถานะ $\vert0\rangle$

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) ถัดมา สร้าง superposition สิ่งที่ต้องทำคือไปถึงสถานะ $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) รวมสองข้อข้างต้น สิ่งที่ต้องทำคือไปถึงสถานะ $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$

คุณสามารถรวมสองงานข้างต้นเพื่อหาคำตอบได้ไหม?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) สุดท้าย ก้าวเข้าสู่จำนวนเชิงซ้อน สิ่งที่ต้องทำคือไปถึงสถานะ $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quantum Quiz with Multi-Qubit Gates

เยี่ยมมาก! ตอนนี้ที่เข้าใจ single-qubit Gate แล้ว มาดู Gate ที่ทำงานกับ Qubit หลายตัวกันต่อ ในส่วนนี้จะให้แก้ปัญหา quantum state quiz จำนวน 4 ข้อ โดยผสมระหว่าง single-qubit Gate และ multi-qubit Gate โดย Gate พื้นฐานสำหรับ Qubit สองตัวมีดังนี้

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

ถ้าอยากอ่านเพิ่มเติมเกี่ยวกับ multi-qubit Gate ต่าง ๆ และความสัมพันธ์ระหว่างกัน แวะไปที่ Quantum Information of multiple systems ในคอร์ส Basics of Quantum Information ของ John ได้เลย

สำหรับ Qubit สองตัว สถานะทั่วไปอยู่ในรูป $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ โดยที่ $a$ , $b$ , $c$ , และ $d$ เป็นจำนวนเชิงซ้อน ซึ่งกำลังสองของค่าสัมบูรณ์แต่ละตัวให้ค่าความน่าจะเป็นในการวัดสถานะนั้น ๆ เช่น $|a|^2$ คือความน่าจะเป็นที่จะได้ผล '0' บน Qubit ทั้งสอง ซึ่งหมายความว่าตอนนี้ qsphere สามารถมีได้ถึงสี่จุด

เริ่มต้นด้วย two-qubit Gate แบบ canonical นั่นคือ controlled-NOT (หรือเรียกว่า CNOT หรือ CX) Gate ในที่นี้ เช่นเดียวกับ controlled two-qubit Gate ทุกตัว จะมี Qubit หนึ่งตัวทำหน้าที่เป็น "control" และอีกตัวเป็น "target" ถ้า control qubit อยู่ในสถานะ $|0\rangle$ จะใช้ identity $I$ Gate กับ target คือไม่มีการดำเนินการใด ๆ แต่ถ้า control qubit อยู่ในสถานะ $|1\rangle$ จะใช้ X-gate กับ target qubit ดังนั้น เมื่อทั้งสอง Qubit อยู่ในสถานะคลาสสิกอย่างใดอย่างหนึ่ง คือ $|0\rangle$ หรือ $|1\rangle$ CNOT Gate จะถูกจำกัดอยู่แค่การดำเนินการแบบคลาสสิก

สถานการณ์เปลี่ยนไปอย่างมากเมื่อเราใช้ Hadamard Gate กับ control qubit ก่อน เพื่อนำมันเข้าสู่สถานะ superposition $|+\rangle$ การกระทำของ CNOT Gate บน input ที่ไม่ใช่คลาสสิกแบบนี้สามารถสร้างสถานะ entanglement สูงระหว่าง control และ target qubit ได้ ถ้า target qubit อยู่ในสถานะ $|0\rangle$ ในตอนแรก สถานะที่ได้จะเขียนแทนด้วย $|\Phi^+\rangle$ และเป็นหนึ่งใน Bell states ที่เรียกกันว่านั้น

i) สร้าง Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$

สำหรับสถานะนี้จะมีความน่าจะเป็น $\frac{1}{2}$ ที่จะวัดได้ "00" และความน่าจะเป็น $\frac{1}{2}$ ที่จะวัดได้ "11" ซึ่งหมายความว่าผลลัพธ์ของ Qubit ทั้งสองมีความสัมพันธ์กันอย่างสมบูรณ์

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

ต่อไป ลองสร้างสถานะของ Qubit ที่มีความสัมพันธ์ตรงกันข้ามอย่างสมบูรณ์ สังเกตเครื่องหมายลบที่นี่ ซึ่งบ่งบอกถึง relative phase ระหว่างสองสถานะ

ii) สร้าง Bell state $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) โจทย์ให้ quantum Circuit ตามฟังก์ชันด้านล่าง ให้สลับสถานะของ Qubit แรกและ Qubit ที่สองเพื่อให้ได้ QSphere นี้

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) เขียนโปรแกรมตั้งแต่ต้นเพื่อสร้าง GHZ state (บน Qubit สามตัว) $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Run your circuit and see the measured result with a real quantum computer

ตอนนี้เรารู้วิธีสร้าง quantum Circuit เพื่อจัดการ statevector ของ Qubit แล้ว และถึงเวลาสำหรับส่วนที่น่าตื่นเต้นที่สุด นั่นคือการรันและดูผลลัพธ์! ในส่วนนี้จะได้เรียนรู้วิธีสมัยใหม่และมีประสิทธิภาพในการรัน Circuit โดยใช้ Qiskit

Qiskit pattern คือ framework ทั่วไปสำหรับแบ่งปัญหาเฉพาะทางออกเป็นส่วน ๆ และจัดระบบความสามารถที่จำเป็นในแต่ละขั้นตอน ช่วยให้ความสามารถใหม่ ๆ ที่พัฒนาโดยนักวิจัย IBM Quantum (และคนอื่น ๆ) สามารถประกอบเข้าด้วยกันได้อย่างราบรื่น และเปิดทางสู่อนาคตที่งาน quantum computing ถูกดำเนินการโดยโครงสร้างพื้นฐานการประมวลผลแบบ heterogeneous (CPU/GPU/QPU) ที่ทรงพลัง

สี่ขั้นตอนของ Qiskit pattern มีดังนี้

Map — แปลงปัญหาไปเป็น quantum Circuit และ operator
Optimize — ปรับแต่งสำหรับฮาร์ดแวร์เป้าหมาย
Execute — รันบนฮาร์ดแวร์เป้าหมาย
Post-process — ประมวลผลผลลัพธ์

เราเพิ่งทำ Step 1: Mapping เสร็จ โดยสร้าง quantum Circuit เพื่อสร้าง quantum state ที่ต้องการ ตอนนี้มาผ่านขั้นตอนที่เหลือเพื่อดูผลลัพธ์กัน

Optimize

ในส่วนนี้จะตั้งค่า Backend สำหรับรัน Circuit โดยเลือก least busy QPU ในกลุ่ม QPU ที่เข้าถึงได้ หรือเลือก simulator ถ้าไม่มีเวลา GPU เหลือเพียงพอ เมื่อเลือก Backend แล้ว pass_manager จะ transpile Circuit ไปยัง native gate set ของ Backend ที่เลือก และปรับแต่งให้ได้ผลลัพธ์ที่ดีขึ้น สามารถประกาศ pass_manager ได้ง่าย ๆ โดยใช้ generate_preset_pass_manager และตั้ง optimization_level ซึ่งตัวเลขยิ่งสูงหมายถึงขั้นตอนการปรับแต่งยิ่งมาก

ขั้นตอนถัดไปน่าตื่นเต้นมาก เราจะรัน quantum Circuit โดยใช้ Qiskit Runtime!

จะทำโดยใช้ Qiskit primitives สองตัว ได้แก่

Sampler — สุ่มตัวอย่าง output register จากการรัน quantum Circuit หนึ่งตัวหรือมากกว่า โดย output จะเป็น counts จากการวัดแต่ละ shot
Estimator — คำนวณค่าคาดหวัง (expectation value) ของ observable หนึ่งตัวหรือมากกว่าเทียบกับสถานะที่ได้จาก quantum Circuit โดย output ประกอบด้วยค่าคาดหวังพร้อม standard error

ในที่นี้จะใช้ Sampler เพื่อรัน Circuit ของเรา โค้ดด้านล่างแสดงวิธีกำหนด Backend และ pass manager ก่อน จากนั้นจะเพิ่ม measurement ให้กับ Circuit ทุกตัวและสร้าง array ของ quantum Circuit (pub) เพื่อส่งให้ Sampler

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Execute

มารันการ Circuit ของเรากัน ในกรณีที่มีคิวรอนานที่ cloud ให้พิมพ์และบันทึก job_id ไว้ใช้ในภายหลัง และตรวจสอบสถานะงาน หลังจากเห็น job status เปลี่ยนเป็น Done ให้ดึงผลลัพธ์ของงานกลับมา

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-process

ขั้นตอนสุดท้ายคือการตีความการแสดงผลเพื่อทำความเข้าใจ quantum state ที่สร้างขึ้น ก่อนพล็อตกราฟหลายตัว ให้ดึง counts ทั้งหมดจากทุก Circuit ก่อน จากนั้นจะสร้าง 4 กราฟโดยจัดกลุ่ม Circuit

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

The Single Qubit States

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

The Superpositioned One Qubit States

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Two Qubit States

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Three Qubit States

plot_distribution(counts_all[8], legend=['qc9'])

Further challenge

เจอ noise ในผลการทดลองบน Backend จริงบ้างไหม? การลด noise ของ Qubit เป็นหนึ่งในพื้นที่วิจัยที่กำลังพัฒนาอยู่ ลองใช้ Qiskit Runtime's various error mitigation and surpression options เพื่อดูว่า noise ในผลการรันเปลี่ยนแปลงอย่างไร! (หมายเหตุ) ตัวเลือกเหล่านี้ใช้เวลา QPU มากขึ้น

Additional Info

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. เริ่มต้นด้วยสิ่งแรก: Qiskit​

Qiskit คืออะไร​

ติดตั้ง Qiskit​

การแก้ปัญหาเมื่อติดตั้งไม่สำเร็จ​

2. ตั้งค่าบัญชี IBM Cloud ของคุณ ​

3. Circuit ควอนตัมแรกของคุณ​

Quantum circuit คืออะไร​

การทำงานพื้นฐานกับ Qubit และการวัด​

การแทนสถานะ Qubit เดี่ยว​

การแสดงภาพสถานะควอนตัม​

การจัดการ Qubit​

แบบฝึกหัด: Quantum Circuit ด้วย Single-Qubit Gate​

i) เริ่มจาก bit flip สิ่งที่ต้องทำคือไปถึงสถานะ ∣1⟩\vert1\rangle∣1⟩ โดยเริ่มจากสถานะ ∣0⟩\vert0\rangle∣0⟩​

ii) ถัดมา สร้าง superposition สิ่งที่ต้องทำคือไปถึงสถานะ ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩)​

iii) รวมสองข้อข้างต้น สิ่งที่ต้องทำคือไปถึงสถานะ ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩)​

4. Quantum Quiz with Multi-Qubit Gates​

i) สร้าง Bell state ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩)​

ii) สร้าง Bell state ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩)​

iii) โจทย์ให้ quantum Circuit ตามฟังก์ชันด้านล่าง ให้สลับสถานะของ Qubit แรกและ Qubit ที่สองเพื่อให้ได้ QSphere นี้​

5. Run your circuit and see the measured result with a real quantum computer​

Optimize​

Execute​

Post-process​

Further challenge​

Additional Info​